// JavaScript Document
//目前应用层不可继承应用层的其他模块
((function(a){
	var root = ((function(){
		var path = document.scripts;
			path = path[path.length - 1].src.substring(0, path[path.length - 1].src.lastIndexOf("/") + 1)
		return path;
	})());
	//这个是用于存储方法的方法
	var ready = function(func){
		if(typeof(func)=='function'){
			this.__proto__.readyFunction = func;
		}
	}
	
	//这个是唤醒存储方法的方法
	var doReady = function(){
		debug('系统初始化成功，执行用户方法','process');
		this.readyFunction();
	}
	
	//执行异步需要处理的东西们
	var doSync = function(){
		debug('系统初始化开始','process');
		var ths = this;
		ths._initmodels(function(){
			ths._initResource(function(){
				//资源加载完成
				//执行内核判定
				debug('执行内核判定,开始根据当前信息判定系统内核信息','process');
				ths.core = ths.getModel(ths.config.core);
				//执行定义返回
				//todo--执行定义返回
				ths.doReady();	
			});	
		});
	}
	
	var debug = function(msg,info){
		console.warn(msg);	
	}
	
	//基础对象信息
	var kuoqiapp = function(){
		this.__proto__ = b;
		this.init = d;//这个是init初始化
		this.ready = ready;//这个是ready初始化
		this.library = {};
	}
	//这个是配置文件的基础信息
	var config = {
		boxElement:'',//传说中的盒子元素
		version:'',//当前加载版本号
		core:'kuoqi.core.html',//使用基础的内核信息
		//模块加载信息，这种就是js脚本的加载
		//默认加载的模块
		models:[
			//支持直接路径加载,加载系统核心执行文件
			{path:'./lib/index.js',isRoot:1},
			//内核的相关基础
			{path:'./lib/core.js',isRoot:1},
			//数据渲染的模块
			//{path:'./lib/core/display.js',isRoot:1},
			//内核信息，转换内容区域与浏览器代码专用
			//{path:'./lib/core/canvas.js',isRoot:1},
			//canvas动画
			//{path:'./lib/core/animation.js',isRoot:1},
			//元素基础
			//{path:'./lib/core/document.js',isRoot:1},
		],
		//资源加载信息,这种就是除了js脚本其他的脚本的加载
		//默认加载的资源程序
		//name:资源名称
		//path：使用路径加载
		//{path:'./template/demo.html',isRoot:1,name:'demo'}
		//type:'',资源类型，支持[html,image.....]
		resource:[
			//{path:'./template/demo.html',isRoot:1,name:'demo',type:'html'}
		],
	};
	
	//定义一个模型
	var defineModel = function(route,opts){
		var model = this.opts(opts,{
			isInit:0,//是否进行初始化
			//这个为当前model的初始化方法，每一个自动执行的时候都会强制调用这个方法
			//可以用来初始化加载的时候使用
			init:function(){},
		});
		model.route = route;//初始化model的路由信息
		//执行初始化步骤
		model.doInit = function(){
			//初始化的方法，将本对象加入到系统列表中
			if(typeof(this.app.library.models)!='object'){
				this.app.library.models = {};
			}
			this.app.library.models[route] = model;
			//判定是否有继承的路由信息
			if(model.extends){
				//判定是否存在
				var pmodel = this.app.getModel(model.extends);
				for(var i in pmodel){
					if(model[i]!=undefined){ continue;}
					model[i] = pmodel[i];	
				}
				model.isInit = 1;	
			}else{
				model.isInit = 0;	
			}
			model.init();
		};
		model.doInit();
	};
	
	var initModel = function(callback){
		//系统化model路径
		var ths = this;
		var count = ths.config.models.length;
		var now = 0;
		var loadjs = function(){
			//判断当前是否存在
			if(ths.config.models[now]){
				var path = ths.initPath(ths.config.models[now]);
				ths.loadJs(path,function(rs){
					//尝试将临时的model进行归类
					//todo--将tmp_model进行归类放置
					loadjs(++now);
				});
			}else{
				//这个表示加载已经完成	
				debug('model init success','process');
				callback();
			}
		}
		loadjs();
	};
	
	//资源对象的一些初始化
	var _initResobject = function(path,blob){
		if(typeof(this.library.resource)!='object'){
			this.library.resource = {};
		}
		this.library.resource[path.name] = new function KuoqiResource(){
			var ths = this;
			this.blob = blob;
			this.name = path.name;	
			this.img = null;
			//自动将资源包转换为图片资源
			this.getElementByimg = function(callback){
				ths.img = $Q.createElement('img');
				ths.img.src = window.URL.createObjectURL(this.blob);
				ths.img.onload = function(){
					callback&&callback(ths.img);	
				}
			}
		}
		return this.library.resource[path.name];
	}
	
	var initResource = function(callback){
		var ths = this;
		var count = ths.config.resource.length;
		var now = 0;
		var loadresource = function(){
			if(ths.config.resource[now]){
				var path = ths.initPath(ths.config.resource[now]);
				ths.loadResource(path,function(rs){
					ths._initResobject(ths.config.resource[now],rs);
					//尝试将临时的model进行归类
					loadresource(++now);
				});
			}else{
				//这个表示加载已经完成	
				debug('resource init success','process');
				callback();
			}
		}
		loadresource();
	};
	
	//初始化路径的函数信息
	var initPath = function(path,isRoot){
		return this.opts(path,{
			isRoot:(isRoot==undefined)?0:1,
			getRoot:function(){
				if(this.isRoot){
					//使用系统根目录加载
					return this.app.root + (this.version?(this.path+'?v='+this.version):(this.path));
				}else{
					//使用用户根目录加载
					return this.app.app_root + (this.version?(this.path+'?v='+this.version):(this.path));	
				}
			},
		},'path');
	}
	
	//加载一个资源信息
	var loadResource = function(opts,callback){
		if(!opts.name){
			console.error('资源'+opts.path+"未绑定资源名称，无法加载,请使用【object.name】进行资源名称绑定");
			return;	
		}
		var proxy = $Q.proxy({
			action:opts.getRoot(),
			dataType:'blob',
			responseType:'blob',
			success:function(rs){
				callback(rs);
			},
			error:function(){
				console.error('资源'+opts.path+"加载失败");
			}
		});
		proxy.send();
	}
	
	//loadJs
	//加载一个js脚本
	var loadJs = function(opts,callback){
		var ths = this;
		var script = window.document.createElement("script");
		script.type = 'text/javascript';
		script.src = opts.getRoot();
		script.onload = script.onreadystatechange = function() {
			if (!this.readyState || this.readyState === "loaded" || this.readyState === "complete" ) {
				callback(true);
				script.onload = script.onreadystatechange = null;
			}
		};
		script.onerror = function(){
			callback(false);;
		}
		script.setAttribute('data-ktmp','');
		window.document.getElementsByTagName("head").item(0).appendChild(script);
	};
	
	//参数输入
	var optionsInput = function(options,initObject,defCode){
		var obejct = {};
		obejct.app = this;
		obejct['version'] = 'base';
		for(var i in obejct){
			if(initObject[i]==undefined){
				initObject[i] = obejct[i];
			}
		}
		if(typeof(options)=='object'){
			if(Object.prototype.toString.call(options).indexOf('[object HTML')==0){
				var tmp = options;	
				options = {element:tmp};
			}
		}else{
			if(defCode==undefined){defCode='text'}
			var tmp = options;	
			options = {};
			options[defCode] = tmp;
		}
		for(var i in options){
			initObject[i]=options[i];	
		}
		return initObject;
	};
	
	//创建节点渲染的相关信息
	var create = function(){
		console.log(this.core);
		//内核渲染，这里也是要做一个异步的方式喔，这个本来就是异步的方式做
		this.core.flush();//执行内核的最终渲染
		
	};
	
	var getModel = function(route){
		if(this.library.models[route]){
			return this.library.models[route];
		}else{
			debug('获取模型失败-模型不存在','开发中');	
			return;
		}
	}
	
	var getResource = function(name){
		return this.library.resource[name];
	}
	
	var createModel = function(route,cfgs){
		var __proto__ = this.getModel(route);
		var model = {};
		for(var i in __proto__){
			model[i] = __proto__[i];
		}
		for(var i in cfgs){
			model[i] = cfgs[i];
		}
		return model;
	}
	
	//获取内核对象的相关信息
	var getCore = function(){
		return this.core;
	}
	
	
	
	
	//基础对象信息
	var b = {
		root:'library.dev/',//这个是当前的主文件root
		app_root:'',//app的根目录
		doReady : doReady,//这个是唤醒存储方法的方法
		doSync : doSync,//执行异步需要处理的东西们
		//初始化对象
		init:kuoqiapp,
		promise:a.Promise,
		_initmodels:initModel,//初始化model部分的函数
		_initResource:initResource,//初始化资源信息
		_initResobject:_initResobject,//初始化一个数据对象信息
		loadJs:loadJs,//加载一个js
		loadResource:loadResource,//加载一个常规资源信息进入到平台
		initPath:initPath,//初始化一个路径信息
		opts:optionsInput,//参数初始化
		define:defineModel,//定义一个可用的模型
		create:create,//创建渲染
		getModel:getModel ,//获取一个模型信息，根据模型的路由ID
		createModel:createModel,//创建一个model,里面的所有数据都是基于新的的数据，除了dom元素的相关信息
		debug:debug,//异常检查函数
		getCore:getCore,//获取内核对象的相关信息
		getResource:getResource,//获取一个资源对象
	};
	
	
	//执行初始化信息
	//init--执行方法--这里是初始化的方法部分
	var d = function(opts){
		debug('初始化系统函数[app.init]','process');
		//Promise
		//promise 是目前 JS 异步编程的主流解决方案
		//初始化root
		this.root = root+this.root;
		
		//配置app_root
		if(opts.app_root){
			this.app_root = opts.app_root;
		}
		//这里执行初始化的代码
		//初始化代码执行完成
		//doReady();
		//异步执行方法
		this.config = config;
		if(opts.core){
			this.config.core = opts.core;	
		}
		//关于盒子元素
		if(opts.boxElement){
			this.boxElement = $Q(opts.boxElement);	
		}else{
			this.boxElement = $Q('body').first();		
		}
		//关于model加载
		if(opts.models){
			for(var i=0;i<opts.models.length;i++){
				this.config.models.push(opts.models[i]);
			}	
		}
		
		//关于资源加载
		if(opts.resource){
			for(var i=0;i<opts.resource.length;i++){
				this.config.resource.push(opts.resource[i]);
			}	
		}
		
		this.doSync();//执行异步需要处理的东西们
		return this;
	}
	
	
	//初始化
	a.Kapp = a.KApp = new b.init();
})(this));